import { Injectable } from '@angular/core';
import { Http, Response, Headers } from '@angular/http';

import { Observable } from 'rxjs/Rx';
import { Store } from '@ngrx/store';
import { AppState } from '../entity/appState.model';
import { Login, Register, User} from '../entity/user.model';
import * as UserActions from '../actions/user.action';

import { av_api } from '../../config/config';
import * as Constant from '../../constant/constant';
import { ToastService } from '../utils/toast.service';
import { LoadingService } from '../utils/loading.service';
import { AlertService } from '../utils/alert.service';
import {removeEmpty} from "../../utils/basic";
/***
 * 用户相关服务
 * */

// sdk 禾穆
declare const hmApi;
declare const hmcloud;
declare const AV;

@Injectable()
export class UserService {

  private userId$: Observable<string>;

  constructor(
    private toastCtrl: ToastService,
    private loadingCtrl: LoadingService,
    private alertCtrl: AlertService,
    private http: Http,
    private store$: Store<AppState>,
  )
  {
    this.userId$ = this.store$.select(AppState=>AppState.auth)
      .filter(auth=> auth.login !== null && !auth.hasError)
      .map(auth=> auth.login.userId);
  }

  /*** 获取用户store
   * */
  public getUser(): Observable<User>
  {
    return this.store$.select(AppState => AppState.user);
  }
  /*** 登录
   * @param login 登录信息
  * */
  public findLogin(login: Login): Observable<any>
  {
    const { username, password }= login;
    let self= this;
    return Observable.from((async function(){
      await self.logout();
      try{
        const data = await new Promise((resolve, reject)=>{
          hmApi.clientLogin(username, password,(err, result)=>{
            if(err && typeof err === 'string') {
              reject({message: err});
              return;
            }
            if(err){
              const { code }= err;
              if(Object.is(code,210)){
                reject({message: '用户名和密码不匹配'});
                return;
              }
              if(Object.is(code,211)){
                reject({message: '用户不存在'});
                return;
              }
              if(Object.is(code,219)){
                reject({message: '登录失败的次数超过限制,账户将展示冻结15分钟'});
                return;
              }
              reject({message: Constant.SERVE_ERROR});
              return;
            }
            resolve(result);
          });
        });
        return data;
      }catch(err) {
        throw err;
      }
    })());
  }

  /*** 退出
  * */
  public logout(): void
  {
    if (hmcloud.User.current())
      hmcloud.User.logOut();
  }

  /*** 检查用户信息是否注册
   * @param phone 手机号码
   * */
  public checkTelephone(phone: string): Observable<any>
  {
    return Observable.from((async function(){
      try{
        const data = await new Promise((resolve, reject)=>{
          hmApi.checkUserById(phone,(err, result)=>{
            if(err && typeof err === 'string') {
              reject({message: err});
              return;
            }

            if(err){
              reject({message: Constant.SERVE_ERROR});
              return;
            }

            resolve(result);
          });
        });
        return data;
      }catch(err) {
        throw err;
      }
    })());
  }

  /*** 获取短信验证码/再次获取
   * @param phone 手机号码
   * */
  public sendSmsCode(phone: string): Observable<any>
  {
    return Observable.from((async function(){
      try{
        const data = await new Promise((resolve, reject)=>{
          hmApi.requestSmsCode(phone,(err, result)=>{
            if(err && typeof err === 'string') {
              reject({message: err});
              return;
            }

            if(err){
              const { code }= err;
              if(Object.is(code,127)){
                reject({message: '无效的手机号码'});
                return;
              }
              if(Object.is(code,601)){
                reject({message: '发送短信过于频繁,请稍后再试'});
                return;
              }
              if(Object.is(code,602)){
                reject({message: '发送短信验证码失败,请确定手机号码是否正确'});
                return;
              }
              reject({message: Constant.SERVE_ERROR});
              return;
            }

            resolve(result);
          });
        });
        return data;
      }catch(err) {
        throw err;
      }
    })());
  }

  /*** 用户注册
   * @param reg 注册信息
   * */
  public addUser(reg: Register): Observable<any>
  {
    const { username: phone, msgCode: code}= reg;
    return Observable.from((async function(){
      try{
        const data = await new Promise((resolve, reject)=>{
          hmApi.signUpOrlogInWithMobilePhone(phone,code,(err, result)=>{
            if(err && typeof err === 'string') {
              reject({message: err});
              return;
            }

            if(err){
              const { code }= err;
              if(Object.is(code,603)){
                reject({message: '短信验证码错误'});
                return;
              }
              reject({message: Constant.SERVE_ERROR});
              return;
            }

            hmcloud.User.current().set("password",reg.password);
            hmcloud.User.current().save();
            hmcloud.User.current().set("password",null);
            resolve(result);

          });
        });
        return data;
      }catch(err) {
        throw err;
      }
    })());
  }

  /*** 忘记密码
   * 1. 获取短信验证码/再次获取
   * @param phone 手机号码
   * */
  public sendSmsCodeWhenForget(phone: string): Observable<any>
  {
    return Observable.from((async function(){
      try{
        const data = await new Promise((resolve, reject)=>{
          hmApi.requestPasswordResetBySmsCode(phone,(err, result)=>{
            if(err && typeof err === 'string') {
              reject({message: err});
              return;
            }

            if(err){
              const { code }= err;
              if(Object.is(code,119)){
                reject({message: '该服务在维护中,请等待上线'});
                return;
              }
              if(Object.is(code,211) || Object.is(code,213)){
                reject({message: '请确定该手机号码,已注册本平台'});
                return;
              }
              if(Object.is(code,127)){
                reject({message: '无效的手机号码'});
                return;
              }
              if(Object.is(code,601)){
                reject({message: '发送短信过于频繁,请稍后再试'});
                return;
              }
              if(Object.is(code,602)){
                reject({message: '发送短信验证码失败,请确定手机号码是否正确'});
                return;
              }
              reject({message: Constant.SERVE_ERROR});
              return;
            }

            resolve(result);
          });
        });
        return data;
      }catch(err) {
        throw err;
      }
    })());
  }

  /*** 忘记密码
   * 2. 更新密码
   * @param forget 忘记密码表单信息
  * */
  public updatePassword(forget: Register): Observable<any>
  {
    const { username,msgCode: code, password: newPassword }= forget;
    return Observable.from((async function(){
      try{
        const data = await new Promise((resolve, reject)=>{
          hmApi.resetPasswordBySmsCode(username ,(err, result)=>{
            if(err && typeof err === 'string') {
              reject({message: err});
              return;
            }

            if(err){
              const { code }= err;
              if(Object.is(code,603)){
                reject({message: '短信验证码错误'});
                return;
              }
              reject({message: Constant.SERVE_ERROR});
              return;
            }

            resolve(result);
          });
        });
        return data;
      }catch(err) {
        throw err;
      }
    })());
  }

  /*** 修改密码(原密码)
   * @param reset_password 重置密码
   * */
  public updatePwdByOldPwd(reset_password): Observable<any>
  {
    const headers = new Headers({
      'X-LC-Id': AV._config.applicationId || '',
      'X-LC-Key': AV._config.applicationKey || '',
      'X-LC-Session': AV.User.current() && AV.User.current()._sessionToken,
      'Content-Type': 'application/json',
    });
    return this.userId$.flatMap(user_id=>
      this.http.put(`${av_api}/1.1/users/${user_id}/updatePassword`,
        JSON.stringify(reset_password),
        {headers: headers})
    ).map(res=> res.json() as User)
      .catch(this.handleError);
  }

  /*** 用户相关操作(通讯录)
   * 1. 注册时保存所有通讯录
   * */
  public saveContactsWhenReg(contacts): Promise<any>
  {
    return new Promise((resolve, reject)=>{
      hmApi.saveContact(contacts, (err, result)=>{

        if(err && typeof err === 'string') {
          reject({message: err});
          return;
        }

        if(err){
          reject({message: Constant.SERVE_ERROR});
          return;
        }
        resolve(result);
      });
    });
  }

  /*** 用户相关操作
   * 2.1 更新用户信息主表
   * ps: 先更新主表然后副表
   * @param userInfo  主表信息
  * */
  public updateUser(userInfo: any): Promise<any>
  {
    return new Promise((resolve, reject) => {
      hmApi.updateUser(JSON.stringify(userInfo),(err, result)=>{
        if(err) {
          console.error(err);
          reject(err);
          return;
        }

        if(!result){
          reject({message:''});
          return;
        }
        resolve(result);
      });
    });
  }

  /*** 用户相关操作
   * 2.2 更新用户详情表
   * @param userDetails 详情副表信息
  * */
  public updateUserDetails(userDetails: any): Promise<any>
  {
    return new Promise((resolve, reject) => {
      hmApi.updateUserInfo(JSON.stringify(userDetails),(err, result)=>{
        if(err) {
          console.error(err);
          reject(err);
          return;
        }

        if(!result){
          reject({message: Constant.SERVE_ERROR});
          return;
        }
        resolve(result);
      });
    });
  }

  /*** 用户相关操作(认证状态)--(认证中心)
   * 3.1 认证中心查询用户认证状态Api
   * */
  public getUserInfoApi(): Promise<any>
  {
    return new Promise((resolve, reject) =>{
      hmApi.getUserInfo((err, result)=>{
        if(err) {
          reject(err);
          return;
        }
        if(!result) {
          reject(Constant.SERVE_ERROR);
        }
        resolve(result);
      });
    });
  }

  /*** 用户相关操作(认证状态)--(认证中心)
   * 3.2 进入认证中心查询用户认证状态
   * @param refresher
   * */
  public getUserInfoFromBack(refresher): void
  {
    this.getUserInfoApi().then(result=>{
      // 若获取成功
      if(refresher){ refresher.complete(); }
      this.store$.dispatch(new UserActions.SaveAuthStatusAction(result));
    }).catch(err=>{
      if(refresher){ refresher.complete(); }
      this.toastCtrl.createCenterToast(Constant.SERVE_ERROR);
      console.error(err);
    });
  }

  /*** 用户相关操作(个人信息认证)--(认证中心个人信息)
   * 4.1 识别身份证获取信息
   * @param BaseFile 身份证base64文件,不包含(data:image/png;base64,)
   * @param fileMine 图片类型(jpg/png/bmp)
   * */
  public getIdCardByUploadImage(BaseFile: string,fileMine: string= 'jpeg'): void
  {
    if(!BaseFile) return;

    hmApi.getIdCard(BaseFile,fileMine,(err, result)=>{
      if(err) {
        console.error(err);
        return;
      }
      let obj= JSON.parse(result);
      if(!obj){
        return;
      }
      if(!obj.data.item){
        this.toastCtrl.createCenterToast(Constant.GET_ID_CARD_FAILED);
        return;
      }
      this.store$.dispatch(new UserActions.UpdateCardInfoAction(obj.data.item));
    });
  }

  /*** 用户相关操作(个人信息认证)--(认证中心个人信息)
   * 4.2 身份证和人脸对比
   * @param imageCard 身份证base64文件,不包含(data:image/png;base64,)
   * @param imageFace 人脸base64文件,不包含(data:image/png;base64,)
   * */
  public getFaceContrastByUploadImage(imageCard: string,imageFace: string): void
  {
    if(!(imageFace && imageCard)) return;

    hmApi.getFaceContrast(imageCard,imageFace,(err, result)=>{
      if(err) {
        console.error(err);
        return;
      }
      if(result.status && result.status!=='OK'){
        this.alertCtrl.createMessageAlert('身份证和人脸','对比失败,请重新上传');
        return;
      }
      this.store$.dispatch(new UserActions.UpdateFaceContrastAction(result));
    });
  }

  /*** 用户相关操作(个人信息)--(认证中心个人信息)
   * 4.3 上传Base64文件
   * @param data 包含(data:image/png;base64,)的base64编码
   * @param FileName 文件名称加后缀
  * */
  public uploadBase64FileByImage(data: string,FileName: string= new Date().getTime()+'.jpeg'): Promise<any>
  {
    return new Promise((resolve, reject) => {

      // 若文件已经上传, 就跳过上传文件
      if(data.startsWith('http:')){
        resolve(data);
        return;
      }

      hmApi.uploadBase64File(FileName,data,(err, result)=>{
        if(err) {
          console.error(err);
          reject(err);
          return;
        }

        if(!result){
          reject({message: Constant.SERVE_ERROR});
          return;
        }
        resolve(result);
      });
    });
  }

  /*** 用户相关操作(个人信息保存)--(认证中心)
   * 5.1 个人信息用户点击保存接口
   * @param options 需要保存的数据
   * @param navCtrl NavController
   * */
  public uploadImageAndUpdateUserInfo(options: any, navCtrl): void
  {
    let { liveAddr, livingImg, frontImg, backImg, education,
      pass, compareFaceVal, realname, idNo, idState }= options;
    // 首先去比对身份证和人脸
    this.loadingCtrl.createLoading('正在加载中');
    let obj= {};
    this.uploadBase64FileByImage(livingImg).then(url=>{
      obj['livingImg']= url;
      return this.uploadBase64FileByImage(frontImg);
    }).then(url=> {
      obj['frontImg']= url;
      return this.uploadBase64FileByImage(backImg);
    }).then(url=> {
      obj['backImg']= url;
      const user= { education, realname, idNo, idState };
      // 更新主表分表
      return this.updateUser(user);
    }).then(data=>{
      const userDetails= {...obj, liveAddr, pass, compareFaceVal};
      return this.updateUserDetails(userDetails);
    }).then(data=> {
      return this.loadingCtrl.closeLoading();
    }).then(()=>{
      // 若修改成功
      this.store$.dispatch(new UserActions.BindUserInfoAction({ idState, education, liveAddr, ...obj }));
      this.alertCtrl.createAgreeAlert('保存个人信息成功').then(data=>{
        navCtrl.pop();
      });

    }).catch(err=> {
      this.loadingCtrl.closeLoading().then(data=>{
        this.toastCtrl.createCenterToast(err.message);
      });
    })
  }

  /*** 用户相关操作(个人信息保存)--(认证中心)
   * 5.2 不上传文件仅仅更新用户信息( 地址和学历 )
   * @param options 需要保存的数据
   * @param navCtrl NavController
   * */
  public onlyUpdateUserInfo(options: any, navCtrl): void
  {
    let { liveAddr, education }= options;
    // 首先去比对身份证和人脸
    this.loadingCtrl.createLoading('正在加载中');
    let user= { education };
    this.updateUser(user).then(data=>{
      const userDetails= { liveAddr};
      return this.updateUserDetails(userDetails);
    }).then(data=> {
      return this.loadingCtrl.closeLoading();
    }).then(()=>{
      // 若修改成功
      this.store$.dispatch(new UserActions.UpdateUserInfoAction({ liveAddr, education }));

      this.alertCtrl.createAgreeAlert('更新个人信息成功').then(data=>{
        navCtrl.pop();
      });

    }).catch(err=> {
      this.loadingCtrl.closeLoading().then(data=>{
        this.toastCtrl.createCenterToast(err.message);
      });
    })
  }

  /*** 用户相关操作(个人信息保存)--(联系人信息)
   * 6.1 更新联系人信息
   * @param options 需要保存的数据
   * @param navCtrl NavController
   * */
  public updateConacts(options: any, navCtrl): void
  {
    this.loadingCtrl.createLoading('正在加载中');

    let { contact, contactState }= options;
    const user= { contactState };
    const userDetails= { contact };
    Promise.all([
      this.updateUser(user),
      this.updateUserDetails(userDetails),
      this.loadingCtrl.closeLoading(),
    ]).then((results)=> {
        // 若修改成功
        this.store$.dispatch(new UserActions.UpdateContactsAction({ contact, contactState }));
        this.alertCtrl.createAgreeAlert('保存联系人成功').then(data=>{
            navCtrl.pop();
        });
      }).catch(err=> {
      this.loadingCtrl.closeLoading().then(()=>{
        this.toastCtrl.createCenterToast(err.message);
      });
    });

  }

  /*** 用户相关操作(绑定银行卡)--(认证中心收款银行卡)
   * 7.1 银行卡识别
   *  @param options 需要保存的数据
   *  @param viewCtrl ViewController
   * */
  public bindBankCard(options, viewCtrl): void
  {
    this.loadingCtrl.createLoading('正在加载中');
    const { bankName: bank, bankNo, bankphone }= options;
    hmApi.userBindBank({ bank, bankNo, bankphone },(err, result)=>{

      this.loadingCtrl.closeLoading().then(()=>{
        if(err) {
          console.error(err);
          this.toastCtrl.createCenterToast(err.message);
          return;
        }

        if(!result){
          this.toastCtrl.createCenterToast(err.message);
          return;
        }
        // 若修改成功
        this.store$.dispatch(new UserActions.BindBankCardAction({bankState: 1,bankInfo: options }));
        this.alertCtrl.createAgreeAlert('绑定银行卡成功').then(data=>{
          viewCtrl.dismiss();
        });

      });

    });

  }

  /*** 用户相关操作(运营商授权)--(认证中心手机运营商)
   * 8.1 获取运营商token
   *  @param options 需要保存的数据
   * */
  public getMobileAuthToken(options): void
  {
    this.loadingCtrl.createLoading('加载中');
    const { name, idNo, phone }= options;
    hmApi.mobileAuthorize({ name, idNo, phone },(err, result)=>{
      if(err) {
        console.error(err);
        this.loadingCtrl.closeLoading().then(data=>{
          this.toastCtrl.createCenterToast(Constant.SERVE_ERROR);
        });
        return;
      }

      if(!result){
        this.loadingCtrl.closeLoading().then(data=>{
          this.toastCtrl.createCenterToast(Constant.GET_SERVE_DATE_ERROR);
        });
        return;
      }
      // 若修改成功
      this.store$.dispatch(new UserActions.GetMobileTokenAction(result.data));
      this.loadingCtrl.closeLoading();
    });

  }

  /*** 用户相关操作(运营商数据采集)--(认证中心手机运营商)
   * 8.2 运营商登录
   *  @param options 需要保存的数据
   *  @param viewCtrl ViewController
   * */
  public MobileLogin(options, viewCtrl): void
  {
    // ps 此处,因为三方数据库问题,递归3秒。
    const startTime= new Date().getSeconds(); // 开始秒数
    const { token, pwd }= options;
    hmApi.mobileLogin({ token, pwd },(err, result)=>{
      if(err) {
        console.error(err);
        const endTime= new Date().getSeconds(); // 开始秒数
        // 在30秒之内就再次去查
        if(endTime-startTime< 15){
          setTimeout(()=>{
            this.MobileLogin(options, viewCtrl);
          },2000);
          return;
        }
        this.loadingCtrl.closeLoading().then(data=>{
          this.toastCtrl.createCenterToast(Constant.SERVE_TIMEOUT_ERROR);
        });
        return;
      }

      if(!result){
        this.loadingCtrl.closeLoading().then(data=>{
          this.toastCtrl.createCenterToast(Constant.GET_SERVE_DATE_ERROR);
        });
        return;
      }
      // 返回的result的sendMsg。为true,
      if(result.sendMsg){
        // this.store$.dispatch({
        //   type: UserActions.NEED_SEND_MSG_CODE,
        //   payload: { plan: 1 }
        // });
        this.loadingCtrl.closeLoading().then(data=>{
          this.alertCtrl.createFloatInputAlert('验证码已发送,请注意查收').then((data)=>{
            if(data){
              this.loadingCtrl.createLoading('加载中');
              const captcha= removeEmpty(data.msgCode);
              this.mobileDataSave({...options, captcha }, viewCtrl);
            }
          });
        });
        return;
      }
      // 若不需要发送验证码, 直接Save
      this.mobileDataSave(options, viewCtrl);
    });

  }

  /*** 用户相关操作(保存运营商数据)--(认证中心手机运营商)
   * 8.3 运营商认证
   *  @param options 需要保存的数据
   *  @param viewCtrl ViewController
   * */
  public mobileDataSave(options, viewCtrl): void
  {
    let data={};
    // 若有验证码,则传入
    if(options.captcha){
      data['captcha']= options.captcha;
    }
    data['token']= options.token;
    hmApi.mobileDataSave(data,(err, result)=>{
      if(err) {
        console.error(err);
        this.loadingCtrl.closeLoading().then(data=>{
          this.toastCtrl.createCenterToast(Constant.SERVE_ERROR);
        });
        return;
      }

      if(!result){
        this.loadingCtrl.closeLoading().then(data=>{
          this.toastCtrl.createCenterToast(Constant.SERVE_ERROR);
        });
        return;
      }

      this.loadingCtrl.closeLoading().then(data=>{
        return this.alertCtrl.createMessageAlert('运营商认证完成','网络延迟,请等待审核通过');
      }).then(data=>{
        // 成功
        this.store$.dispatch(new UserActions.BindTelephoneAction(result.mobileState));
        viewCtrl.dismiss(result.mobileState);
      });

    });

  }

  /*** 用户相关操作(绑定工作信息)--(认证中心工作信息)
   * 10.1.1 上传工作照
   *  @param options 需要保存的数据
   * */
  public uploadWorkImages(options= []): void
  {
    if(options.length<1) return;
    this.loadingCtrl.createLoading('正在保存中');
    // len长度, index 完成个数, workingImg得到数组
    let workingImg= [],index= 0;
    const len= options.length;
    // 上传事件
    options.forEach(value=> {
      const { url }= value;
      this.uploadBase64FileByImage(url).then(url=>{
        workingImg.push({ url: url, type: ''});
        // 当所有上传完成
        index++;
        if(index=== len){
          this.updateWorkImgArray({ workingImg });
          return;
        }
      }).catch(err=> {
        this.loadingCtrl.closeLoading().then(data=>{
          this.toastCtrl.createCenterToast(Constant.SERVE_ERROR);
        });
      })
    });
  }
  /*** 用户相关操作(绑定工作信息)--(认证中心工作信息)
   * 10.1.1 上传工作照
   *  @param workingImg 返回的照片数组对象
   * */
  private updateWorkImgArray(workingImg): void
  {
    // 然后更新详细表
    this.updateUserDetails(workingImg).then(data=>{
      return this.loadingCtrl.closeLoading();
    }).then(()=>{
      // 若修改成功
      this.store$.dispatch(new UserActions.UploadWorkImgsAction(workingImg));
      this.alertCtrl.createAgreeAlert('保存照片成功');

    }).catch(err=> {
      this.loadingCtrl.closeLoading().then(data=>{
        this.toastCtrl.createCenterToast(err.message);
      });
    })
  }

  /*** 用户相关操作(绑定工作信息)--(认证中心工作信息)
   * 10.2 更新工作信息
   * @param options 需要保存的数据
   * @param navCtrl NavController
   * */
  public updateWorkInfo(options: any, navCtrl): void
  {
    this.loadingCtrl.createLoading('正在加载中');
    let { companyName, companyPhone, workingYears, companyAddr }= options;
    const workState= 1;
    const user= { workState };
    const userDetails= { companyName, companyPhone, workingYears, companyAddr  };
    Promise.all([
      this.updateUser(user),
      this.updateUserDetails(userDetails),
      this.loadingCtrl.closeLoading(),
    ]).then((results)=> {
      // 若修改成功
      this.store$.dispatch(new UserActions.UpdateWorkInfoAction({...options, workState}));
      this.alertCtrl.createAgreeAlert('保存信息成功').then(data=>{
        navCtrl.pop();
      });
    }).catch(err=> {
      this.loadingCtrl.closeLoading().then(()=>{
        this.toastCtrl.createCenterToast(err.message);
      });
    });
  }

  /*** 用户相关操作(绑定更多信息)--(认证中心更多信息)
   * 11.1 保存更多信息
   *  @param options 需要保存的数据
   *  @param navCtrl NavController
   * */
  public updateMoreInfo(options, navCtrl): void
  {
    this.loadingCtrl.createLoading('正在加载中');
    const user= { moreState : 1 };
    const userDetails= { ...options };
    Promise.all([
      this.updateUser(user),
      this.updateUserDetails(userDetails),
      this.loadingCtrl.closeLoading(),
    ]).then((results)=> {
      // 若修改成功
      this.store$.dispatch(new UserActions.UpdateMoreInfoAction({...user,moreInfo: userDetails }));
      this.alertCtrl.createAgreeAlert('保存信息成功').then(data=>{
        navCtrl.pop();
      });
    }).catch(err=> {
      this.loadingCtrl.closeLoading().then((err)=>{
        this.toastCtrl.createCenterToast(err.message);
      });
    });
  }

  /*** 用户反馈
   * 12.1 保存更多信息
   *  @param options 需要保存的数据
   *  {
   *    content 内容
   *    contact 联系方式
   *  }
   *  @param navCtrl NavController
   * */
  public saveFeedback(options, navCtrl): void
  {
    this.loadingCtrl.createLoading('正在提交中');
    const { content, contact }= options;
    hmApi.saveFeedback({ content, contact, },(err, result)=>{

      this.loadingCtrl.closeLoading().then(()=>{
        if(err) {
          console.error(err);
          this.toastCtrl.createCenterToast(Constant.SERVE_ERROR);
          return;
        }
        if(!result){
          this.toastCtrl.createCenterToast(Constant.SERVE_ERROR);
          return;
        }
        // 若修改成功
        this.alertCtrl.createAgreeAlert('提交信息成功').then(data=>{
          navCtrl.pop();
        });
      });

    });
  }


  /*** 错误处理
  * */
  private handleError(error: Response) {
    console.error(error);
    return Observable.throw(error.json().error || Constant.SERVE_ERROR);
  }


}
